// 关联关系
const User = require('./user.model');
const Role = require('./role.model');
const Menu = require('./menu.model');
const Category = require('./product/category.model');
const Brand = require('./product/brand.model');
const attrValue = require('./product/attrValue.model');
const Attr = require('./product/attr.model');
const Spu = require('./product/spu.model');
const SpuImage = require('./product/spuImage.model')
const SpuSale = require('./product/spuSale.model');
const Sku = require('./product/sku.model');
const SkuAttr = require('./product/skuAttr.model');
const SkuSaleAttr = require('./product/skuSaleAttr.model');

// 关联关系
module.exports = (sequelize) => {
  // Role 和 User 之间的多对多关联
  Role.belongsToMany(User, {
    through: 'user_role', // 中间表名称
    foreignKey: 'role_id', // Role 模型的外键
    otherKey: 'user_id',   // User 模型的外键
    timestamps: false,
    as: 'Users', // 显式定义别名
  });

  // User 和 Role 之间的多对多关联
  User.belongsToMany(Role, {
    through: 'user_role', // 中间表名称，必须与 Role 模型中一致
    foreignKey: 'user_id', // User 模型的外键
    otherKey: 'role_id',   // Role 模型的外键
    timestamps: false,
    as: 'Roles', // 显式定义别名
  });

  // 角色-菜单多对多关系
  Role.belongsToMany(Menu, {
    through: 'role_menu',
    foreignKey: 'role_id',
    otherKey: 'menu_id',
    timestamps: false,
    as: 'Menus' // 显式定义别名
  });

  Menu.belongsToMany(Role, {
    through: 'role_menu',
    foreignKey: 'menu_id',
    otherKey: 'role_id',
    timestamps: false,
    // as: 'Roles' // 反向关联别名（可选，但需与查询逻辑匹配）
  });

  // 菜单自关联（树形结构）
  Menu.hasMany(Menu, {
    foreignKey: 'pid',
    as: 'children'
  });

  // Category 和 Brand 之间的多对多关联
  Category.belongsToMany(Brand, {
    through: 'category_brand',
    foreignKey: 'category_id',
    otherKey: 'brand_id',
    timestamps: false,
    as: 'Brands' // 显式定义别名
  });
  
  // Brand 和 Category 之间的多对多关联
  Brand.belongsToMany(Category, {
    through: 'category_brand',
    foreignKey: 'brand_id',
    otherKey: 'category_id',
    timestamps: false,
    as: 'Categories' // 显式定义别名
  });
  
  // 分类自关联（树形结构）
  Category.hasMany(Category, {
    foreignKey: 'praent_id',
    as: 'children'
  });
  Category.belongsTo(Category, {
    foreignKey: 'praent_id',
    as: 'praent'        // 父分类信息（可选）
  });

  // 属性值和属性的多对一关联
  attrValue.belongsTo(Attr, {
    foreignKey: 'attrId',
    as: 'Attrs',      // 别名
  });

  // 属性和属性值的多对一关联
  Attr.hasMany(attrValue, {
    foreignKey: 'attrId',
    as: 'attrValueList',
    onDelete: 'CASCADE',    // 级联删除
  });

  // spu 和 spuImage 的多对一关联
  SpuImage.belongsTo(Spu, {
    foreignKey: 'spuId',
    as: 'SpuImages',
  });
  Spu.hasMany(SpuImage, {
    foreignKey: 'spuId',
    as: 'spuImageList',
    onDelete: 'CASCADE',    // 级联删除
  });

  // spu 和 saleAttr 的一对多关联
  SpuSale.belongsTo(Spu, {
    foreignKey: 'spuId',
    as: 'SpuSales',
  });
  Spu.hasMany(SpuSale, {
    foreignKey: 'spuId',
    as: 'spuSaleAttrList',
    onDelete: 'CASCADE',    // 级联删除
  });
  // 自关联
  SpuSale.hasMany(SpuSale, {
    foreignKey: 'pid',
    as: 'spuSaleAttrValueList'
  })

  // spu 和 sku 的一对多关联
  Sku.belongsTo(Spu, {
    foreignKey: 'spuId',
    as: 'Skus',
  });
  Spu.hasMany(Sku, {
    foreignKey: 'spuId',
    as: 'SkuList',
    onDelete: 'CASCADE',    // 级联删除
  });

  // sku 和 SkuAttrValue 的多对一关联
  SkuAttr.belongsTo(Sku, {
    foreignKey: 'skuId',
    as: 'skuAttr',
  });
  Sku.hasMany(SkuAttr, {
    foreignKey: 'skuId',
    as: 'skuAttrValueList', 
    onDelete: 'CASCADE',    // 级联删除
  });

  // sku 和 SkuSaleAttrValue 的多对一关联
  SkuSaleAttr.belongsTo(Sku, {
    foreignKey: 'skuId',
    as: 'skuSale',
  });
  Sku.hasMany(SkuSaleAttr, {
    foreignKey: 'skuId',
    as: 'skuSaleAttrValueList', 
    onDelete: 'CASCADE',    // 级联删除
  });
};